package com.irdstudio.efp.edoc.service.impl;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONObject;
import com.irdstudio.basic.framework.core.base.FrameworkService;
import com.irdstudio.basic.framework.core.constant.MonAlrmLvlEnums.MonAlrmLvlEnum;
import com.irdstudio.basic.framework.core.constant.StdZbHandleEnums.StdZbHandleEnum;
import com.irdstudio.basic.framework.core.util.DateTool;
import com.irdstudio.basic.framework.core.util.SFTPUtil;
import com.irdstudio.basic.framework.core.util.StringUtil;
import com.irdstudio.basic.framework.core.util.UUIDUtil;
import com.irdstudio.basic.framework.core.util.ZipUtil;
import com.irdstudio.efp.edoc.common.ImageBizConstant;
import com.irdstudio.efp.edoc.common.UploadFileConstant;
import com.irdstudio.efp.edoc.service.bo.ImageBizDetailVO;
import com.irdstudio.efp.edoc.service.bo.LogErrorInfoVO;
import com.irdstudio.efp.edoc.service.bo.UpLoadFileVO;
import com.irdstudio.efp.edoc.service.facade.ImageBizDetailService;
import com.irdstudio.efp.edoc.service.facade.LogErrorInfoService;
import com.irdstudio.efp.edoc.service.facade.PolicyFileAnalysisService;
import com.irdstudio.efp.edoc.service.facade.UpLoadFileService;
import com.irdstudio.efp.esb.common.constant.ElectronicSignatureConstant;
import com.irdstudio.efp.esb.common.constant.ElectronicSignatureEnums;
import com.irdstudio.efp.esb.common.constant.MsLoanConstant;
import com.irdstudio.efp.loan.service.facade.LoanPolicyService;
import com.irdstudio.efp.loan.service.vo.LoanPolicyVO;
import com.irdstudio.efp.nls.service.facade.NlsApplyInfoService;
import com.irdstudio.efp.nls.service.vo.NlsApplyInfoVO;
import com.jcraft.jsch.ChannelSftp;

/**
 * 
 * 交互文件服务-保单文件解析
 * 
 * @author ludayong
 * @since 2019年1月2日 下午7:05:26
 * @version 1.0
 */
@Service("policFileAnalysisService")
public class PolicyFileAnalysisServiceImpl implements PolicyFileAnalysisService, FrameworkService {

	private static Logger logger = LoggerFactory.getLogger(PolicyFileAnalysisServiceImpl.class);

	@Value("${analysis.policFilePath}")
	private String policFilePath;// 保单文件解析路径

	@Value("${analysis.archPolicyFilePath}")
	private String archPolicyFilePath;// 保单文件归档路径

	@Value("${file.remotePolicyDownPath}")
	private String remotePolicyDownPath;// 前置文件服务器：保单下载地址

	@Value("${file.remotePolicyBakPath}")
	private String remotePolicyBakPath;// 前置文件服务器：保单备份地址

	@Value("${ftp.host}")
	private String host;// 前置文件服务器IP地址

	@Value("${ftp.username}")
	private String username;// 前置文件服务器用户名

	@Value("${ftp.pwd}")
	private String pwd;// 前置文件服务器登录密码

	@Value("${ftp.port}")
	private int port;// 前置文件服务器端口号

	@Value("${up_imagesys_flag}")
	private String upImagesysFlag;// 是否上传影像系统

	@Value("${analysis.policy.downNum}")
	private int downNum;// 保单文件下载最多个数

	@Autowired
	@Qualifier("imageBizDetailService")
	private ImageBizDetailService imageBizDetailService;// 影像业务文件

	@Autowired
	@Qualifier("loanPolicyService")
	private LoanPolicyService loanPolicyService;// 保单信息

	@Autowired
	@Qualifier("upLoadFileService")
	private UpLoadFileService upLoadFileService;// 上传影像平台

	@Autowired
	@Qualifier("logErrorInfoService")
	private LogErrorInfoService logErrorInfoService;// 异常信息表

	@Autowired
	@Qualifier("nlsApplyInfoService")
	private NlsApplyInfoService nlsApplyInfoService;// 网贷申请基本信息

	/**
	 * 
	 * 交互文件服务-保单文件解析
	 * 
	 * @param paramMap
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月2日 下午7:06:52
	 * @version 1.0
	 */
	@Override
	public synchronized boolean analysisPolicyFile() throws Exception {
		boolean fileDownRes = downloadFile();// 前置文件服务器下载文件
		long startTime = System.currentTimeMillis();
		logger.info("交互文件服务-保单文件解析：[" + DateTool.formatDate(new Date(startTime), "yyyy-MM-dd HH:mm:ss") + "]， 处理开始！");
		boolean result = false;
		// 1、解压保单文件
		File files = new File(policFilePath);// 解析文件
		File[] policyFiles = files.listFiles();

		if (fileDownRes && files.exists()) {// 文件存在
			if (policyFiles.length > 0) {
				for (File policyFile : policyFiles) {
					if (policyFile.getName().endsWith(ZipUtil.EXT)) {// 单笔保单文件
						try {
							// 1、解压保单文件
							boolean unZipResult = ZipUtil.unZipAll(new File(policyFile.getAbsolutePath()),
									new File(policyFile.getAbsolutePath().replace(ZipUtil.EXT, "")), true);
							if (unZipResult) {
								try {
									result = this.handlePolicFile(policyFile.getAbsolutePath());
								} catch (Exception e) {
									result = false;
									e.printStackTrace();
									logger.error("交互文件服务-保单文件解析出现异常，异常信息" + e.getMessage());
								}
							}
						} catch (IOException e) {
							result = false;
							e.printStackTrace();
							logger.error("交互文件服务-保单文件解压出现异常，异常信息" + e.getMessage());
						}
					} else if (policyFile.isDirectory()) {
						try {
							result = this.handlePolicFile(policyFile.getAbsolutePath());
						} catch (Exception e) {
							result = false;
							e.printStackTrace();
							logger.error("交互文件服务-保单文件解析出现异常，异常信息" + e.getMessage());
						}
					} else {
						result = true;
					}
				}
			}
		}
		long endTime = System.currentTimeMillis();
		logger.info("交互文件服务-保单文件解析：[" + DateTool.formatDate(new Date(endTime), "yyyy-MM-dd HH:mm:ss") + "]， 处理结束！");
		logger.info("交互文件服务-保单文件解析，耗时：[" + (endTime - startTime) / 1000.0 + "]秒！");
		return result;
	}

	/**
	 * 
	 * 1、交互文件服务-保单文件解析（保单）校验影像个数，记录异常
	 * 
	 * @param filePath
	 * @param fileName
	 * @return boolean
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月2日 下午7:06:52
	 * @version 1.0
	 */
	private boolean handlePolicFile(String filePath) throws Exception {
		String analysisPath = filePath;
		if (filePath.endsWith(ZipUtil.EXT)) {// 单笔保单文件
			analysisPath = filePath.replace(ZipUtil.EXT, "");// 解析文件目录
		}
		boolean reslut = false;
		// 1、交互文件服务-保单文件解析（保单）校验影像个数，记录异常
		int num = 0;
		File files = new File(analysisPath);
		File[] policFiles = files.listFiles();

		if (policFiles.length > 0) {
			Map<String, String> policFileMap = new HashMap<String, String>();// 单个保单文件ZIP包
			for (File policFile : policFiles) {
				String policFilePath = policFile.getAbsolutePath();// 文件路径

				String policFileName = policFile.getName();// 文件名
				String loanPolicy = policFileName.substring(0, policFileName.indexOf("."));// 保单号

				// 有PDF格式保单文件，清理多余格式保单文件（非PDF格式）
				if (!policFileName.endsWith(ImageBizConstant.LOAN_PROTOCOL_SUFFIX)) {
					String pdfPolicFilePath = policFile.getParent() + File.separator + loanPolicy + ImageBizConstant.LOAN_PROTOCOL_SUFFIX;// 查询PDF格式保单文件
					File pdfPolicFile = new File(pdfPolicFilePath);
					if (pdfPolicFile.exists() || policFileMap.containsKey(loanPolicy)) {// PDF格式保单文件存在或者本次解析有过该保单其他格式的文件
						boolean removeFileRes = ZipUtil.deleteFile(policFilePath);
						logger.info("清理多余格式保单文件（非PDF格式），目标路径：" + policFilePath + "，结果[" + removeFileRes + "]");
						continue;
					} else {
						policFileMap.put(loanPolicy, loanPolicy);
					}
				} else {
					policFileMap.put(loanPolicy, loanPolicy);
				}

				LoanPolicyVO loanPolicyVO = new LoanPolicyVO();
				loanPolicyVO.setPolicynbr(loanPolicy);
				LoanPolicyVO queryLoanPolicyVO = loanPolicyService.queryByPk(loanPolicyVO);// 查询保单信息
				if (queryLoanPolicyVO != null) {
					String applySeq = queryLoanPolicyVO.getLoanNo();// 借据号（流水号）
					String currentTime = DateTool.getCurrentDateTime();// 当前时间

					LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
					logErrorInfoVo.setApplySeq(queryLoanPolicyVO.getPolicynbr());// 申请流水号
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
					logErrorInfoVo.setCreateTime(currentTime);// 创建时间
					logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间

					// 网贷申请基本信息
					NlsApplyInfoVO inNlsApplyInfoVO = new NlsApplyInfoVO();
					inNlsApplyInfoVO.setApplySeq(applySeq);
					NlsApplyInfoVO queryNlsApplyInfoVO = nlsApplyInfoService.queryByPk(inNlsApplyInfoVO);// 查询网贷申请基本信息
					try {
						Objects.requireNonNull(queryNlsApplyInfoVO);// 网贷申请基本信息不为空
					} catch (Exception e) {
						e.printStackTrace();
						String remark = "该保单关联的网贷申请基本信息为空！";
						logErrorInfoVo.setTableName("nls_apply_info");// 表名
						logErrorInfoVo.setErrorMsg(remark);// 错误信息
						logErrorInfoVo.setRemark(remark);// 备注
						logErrorInfoVo.setErrorType(MonAlrmLvlEnum.WARNING.getEnname());// 错误级别
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
						boolean removeFileRes = ZipUtil.deleteFile(policFile.getAbsolutePath());
						logger.info("清理未识别的保单文件，目标路径：" + policFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
						continue;
					}

					if (StringUtil.isNullorBank(queryNlsApplyInfoVO.getNlsApplyState())
							|| !MsLoanConstant.NlsApplyStateEnum.PASS.VALUE.equals(queryNlsApplyInfoVO.getNlsApplyState())) {
						boolean removeFileRes = ZipUtil.deleteFile(policFile.getAbsolutePath());
						logger.info("清理申请信息审批未通过的保单文件，目标路径：" + policFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
						continue;
					}

					if (StringUtil.isNullorBank(queryNlsApplyInfoVO.getDnSts())
							|| ElectronicSignatureConstant.DN_STS_3.equals(queryNlsApplyInfoVO.getDnSts())) {
						continue;
					}

					if (ElectronicSignatureConstant.DN_STS_0.equals(queryNlsApplyInfoVO.getDnSts())) {
						boolean removeFileRes = ZipUtil.deleteFile(policFile.getAbsolutePath());
						logger.info("清理放款失败申请信息的保单文件，目标路径：" + policFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
						continue;
					}

					if (ElectronicSignatureConstant.DN_STS_2.equals(queryNlsApplyInfoVO.getDnSts())) {
						boolean removeFileRes = ZipUtil.deleteFile(policFile.getAbsolutePath());
						logger.info("清理马上全额放款申请信息的保单文件，目标路径：" + policFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
						continue;
					}

					String savePolicFilePath = archPolicyFilePath + applySeq + File.separator + policFileName;// 实际存放目录

					ImageBizDetailVO imageBizDetailVO = new ImageBizDetailVO();// 影像业务文件
					imageBizDetailVO.setApplySeq(applySeq);// 申请流水号
					imageBizDetailVO.setImageId(UUIDUtil.getUUID());// 影像标识
					imageBizDetailVO.setImageType(ImageBizConstant.IMAGE_TYPE_A06);// 影像类型
					imageBizDetailVO.setFileDesc(ImageBizConstant.FILE_SIGN_LOAN_POLICY_DESC);// 保单
					imageBizDetailVO.setFileName(policFileName);// 文件名
					imageBizDetailVO.setFilePath(savePolicFilePath);// 文件路径
					// imageBizDetail.setBizStage(bizStage);//所属业务阶段
					imageBizDetailVO.setCreateTime(currentTime);// 创建时间
					imageBizDetailVO.setLastModifyTime(currentTime);// 最近修改时间

					int currnum = 0;
					logger.info("当前新增/更新影像业务文件数据为:" + JSONObject.toJSONString(imageBizDetailVO));
					List<ImageBizDetailVO> queryImageBizDetailList = imageBizDetailService.queryByCondition(imageBizDetailVO);
					if (queryImageBizDetailList != null && !queryImageBizDetailList.isEmpty()) {
						currnum = imageBizDetailService.updateByCondition(imageBizDetailVO);
					} else {
						currnum = imageBizDetailService.insertImageBizDetail(imageBizDetailVO);
					}
					num += currnum;
					logger.info("当前新增/更新影像业务文件数据条数为:" + currnum);

					boolean upImageSysReslut = false;// 上传保单文件到影像系统处理结果
					if ("1".equals(upImagesysFlag) && currnum > 0) {
						try {
							upImageSysReslut = updateBatchFileToImageSys(policFilePath, savePolicFilePath, applySeq);// 上传保单文件到影像系统处理结果
							if (!upImageSysReslut) {
								logErrorInfoVo.setErrorMsg("上传保单文件到影像系统出错！");// 错误信息
								logErrorInfoVo.setRemark("上传保单文件到影像系统出错！");// 备注
								logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
								logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
								logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
							}
						} catch (Exception e) {
							logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
							logErrorInfoVo.setRemark(e.getMessage());// 备注
							logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
							logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
							logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
							throw new Exception(e.getMessage(), e);
						}
						logger.info("上传保单文件到影像系统处理结果：[" + upImageSysReslut + "]");
					}
					if ("1".equals(upImagesysFlag) && upImageSysReslut || !"1".equals(upImagesysFlag)) {// 上传保单文件到影像系统处理结果
						boolean moveResult = ZipUtil.moveFile(policFilePath, archPolicyFilePath + applySeq, policFileName, true);// 移动文件
						logger.info(
								"移动文件，目标路径:" + archPolicyFilePath + applySeq + File.separator + policFileName + "结果[" + moveResult + "]");
					}
				} else {
					boolean removeFileRes = ZipUtil.deleteFile(policFile.getAbsolutePath());
					logger.info("清理未识别的保单文件，目标路径：" + policFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
					continue;
				}
			}
			if (num > 0) {
				reslut = true;
			}
			if (filePath.endsWith(ZipUtil.EXT)) {
				String newPath = filePath.replace("\\", "/");
				String fileName = newPath.substring(newPath.lastIndexOf("/") + 1, newPath.length());
				boolean renameReslut = renameFile(remotePolicyDownPath, fileName, remotePolicyBakPath);
				logger.info("前置文件服务器移动文件结果，目标路径：" + remotePolicyBakPath + fileName + "，结果[" + renameReslut + "]");

				if (!renameReslut) {
					String currentTime = DateTool.getCurrentDateTime();// 当前时间
					String remark = "前置文件服务器移动文件出现异常";
					LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
					logErrorInfoVo.setApplySeq(fileName);// 申请流水号
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoVo.setErrorMsg(remark);// 错误信息
					logErrorInfoVo.setRemark(remark);// 备注
					logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
					logErrorInfoVo.setCreateTime(currentTime);// 创建时间
					logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
					logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
					logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
				}

				// ZipUtil.moveDirectory(analysisPath, moveToPath)移动文件
				boolean removeResult = ZipUtil.deleteFile(filePath);// 删除文件
				logger.info("删除文件，目标路径:" + filePath + "结果[" + removeResult + "]");
			}
			File analysisFile = new File(analysisPath);
			File[] analysisFiles = analysisFile.listFiles();
			if (analysisFiles.length == 0) {
				String newPath = filePath.replace("\\", "/");
				File file = new File(newPath);
				if (file.exists()) {
					boolean removeZipResult = ZipUtil.deleteFile(filePath);// 删除文件
					logger.info("删除文件，目标路径:" + filePath + "结果[" + removeZipResult + "]");
				}
				// 路径为文件且不为空则进行删除
				boolean removeResult = ZipUtil.deleteFolder(analysisPath);// 删除空目录
				logger.info("删除空目录，目标路径:" + analysisPath + "结果[" + removeResult + "]");
			}
		}
		return reslut;
	}

	/**
	 * 从前置文件服务器下载文件
	 * 
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月15日 上午8:54:23
	 * @version 1.0
	 */
	private boolean downloadFile() throws Exception {
		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setApplySeq(UUIDUtil.getUUID());// 申请流水号
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		logErrorInfoVo.setCreateTime(currentTime);// 创建时间
		logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间

		List<String> states = new ArrayList<String>();
		states.add(StdZbHandleEnum.PENDING.getEnname());// 未处理
		states.add(StdZbHandleEnum.HANGING.getEnname());// 处理中
		// 连接前置文件服务器
		SFTPUtil sftpUtil = null;
		boolean fileDownRes = false;// 下载文件是否成功
		int downTotal = 0;
		try {
			// 从前置文件服务器下载文件到本地
			sftpUtil = new SFTPUtil(username, pwd, host, port);
			// 检测解析目录是否有需要解析的文件存在
			Vector<ChannelSftp.LsEntry> files = sftpUtil.ls(remotePolicyDownPath);
			Objects.requireNonNull(files);// 文件要存在

			long handTime = System.currentTimeMillis() - 5 * 60 * 1000;
			for (ChannelSftp.LsEntry file : files) {
				String fileName = file.getFilename();// 下载文件名
				long fileMTime = file.getAttrs().getMTime() * 1000L;
				logger.info("处理时间[" + handTime + "]，文件最后修改时间[" + fileMTime + "]");
				if (".".equals(fileName) || "..".equals(fileName) || ZipUtil.EXT.equals(fileName) || !fileName.endsWith(ZipUtil.EXT)) {
					continue;
				} else if (isMatchesCn(fileName)) {
					int num = logErrorInfoService.countByApplySeqAndStates(fileName, states);// 错误信息
					if (num < 3) {// 当前申请流水记录累计出现三次异常且未处理，不获取当前申请流水的保单文件
						String remark = "保单文件命名不规范（包含中文），请检查！";
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoVo.setErrorMsg(remark);// 错误信息
						logErrorInfoVo.setRemark(remark);// 备注
						logErrorInfoVo.setErrorType(MonAlrmLvlEnum.WARNING.getEnname());// 错误级别
						logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					}
					continue;
				} else if (downTotal >= downNum) {
					break;// 每次下载downNum个文件
				} else if (handTime > fileMTime) {// 前置文件服务器下载文件，文件在5分钟以前上传的
					try {
						boolean singleFileDownRes = sftpUtil.downFile(sftpUtil, remotePolicyDownPath, file.getFilename(), policFilePath,
								file.getFilename(), false);
						logger.info("前置文件服务器下载文件：" + remotePolicyDownPath + file.getFilename() + "，结果[" + singleFileDownRes + "]");
						if (singleFileDownRes) {
							downTotal++;// 下载文件数
						}
					} catch (Exception e) {
						e.printStackTrace();
						logger.error("前置文件服务器下载文件出现异常：" + e.getMessage());
					}
				}
			}
			if (downTotal > 0) {// 下载文件数大于0，则解析
				fileDownRes = true;
			}
			logger.info("本次前置文件服务器下载文件数目：[" + downTotal + "]");
		} catch (Exception e) {
			String remark = "前置文件服务器下载文件出现异常！";
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			logErrorInfoVo.setTableName("");// 表名
			logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
			logErrorInfoVo.setRemark(remark);// 备注
			logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
			logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			logger.error(remark + e.getMessage());
			e.printStackTrace();
		} finally {
			if (sftpUtil != null) {
				sftpUtil.closeSFTP();
			}
		}
		return fileDownRes;
	}

	/**
	 * 前置文件服务器移动文件
	 * 
	 * @param filePath
	 * @param fileName
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月15日 上午9:23:42
	 * @version 1.0
	 */
	private boolean renameFile(String oldPath, String fileName, String newPath) throws Exception {
		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setApplySeq(UUIDUtil.getUUID());// 申请流水号
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		logErrorInfoVo.setCreateTime(currentTime);// 创建时间
		logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间

		SFTPUtil sftpUtil = null;
		boolean renameRes = false;
		try {
			// 连接前置文件服务器
			sftpUtil = new SFTPUtil(username, pwd, host, port);
			// 从前置文件服务器移动目录
			renameRes = sftpUtil.renameFile(oldPath, fileName, newPath, true, true);
		} catch (Exception e) {
			String remark = "前置文件服务器移动文件出现异常！";
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			logErrorInfoVo.setTableName("nls_apply_info");// 表名
			logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
			logErrorInfoVo.setRemark(remark);// 备注
			logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
			logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			logger.error(remark + e.getMessage());
			e.printStackTrace();
		}
		return renameRes;
	}

	/**
	 * 
	 * 追加文件文件至影像平台
	 * 
	 * @param vo
	 * @return
	 * @author ludayong
	 * @since 2019年1月18日 上午9:42:35
	 * @version 1.0
	 */
	public boolean updateBatchFileToImageSys(String policFilePath, String savePolicFilePath, String applySeq) throws Exception {
		boolean result = false;
		boolean upImageSysReslut = false;// 上传保单文件到影像系统处理结果
		int upLoadFileNum = 0;// 新增/更新上传影像平台信息数据条数

		UpLoadFileVO vo = new UpLoadFileVO();
		vo.setApplySeq(applySeq);
		String batch = "";
		String startDate = "";
		String ret = "";
		UpLoadFileVO upLoadFileVo = new UpLoadFileVO();

		logger.info("追加保单文件到影像平台请求参数:" + policFilePath + "*******" + savePolicFilePath + "*******" + applySeq);

		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		List<UpLoadFileVO> liatVo = upLoadFileService.queryUploadFile(vo);
		if (Objects.nonNull(liatVo) && !liatVo.isEmpty()) {
			batch = liatVo.get(0).getBatch();// 查询批次号
			startDate = liatVo.get(0).getStartDate();// 查询流水生成时间
			ret = UploadFileConstant.updateBatchFile(applySeq, batch, policFilePath, startDate);// 追加文件
			upLoadFileVo.setApplySeq(applySeq);// 流水号
			upLoadFileVo.setImageType(ImageBizConstant.IMAGE_TYPE_A06);// 影像类型
			upLoadFileVo.setStartDate(startDate);// 流水号生成时间 yyyymmdd
			// upLoadFileVo.setState(state);//状态
			// upLoadFileVo.setStateNum(stateNum);//状态标识
			upLoadFileVo.setBatch(batch);// 批次号码
			upLoadFileVo.setFilePath(savePolicFilePath);// 上传文件路径
			upLoadFileVo.setCreateTime(currentTime);// 创建时间
			upLoadFileVo.setLastModifyTime(currentTime);// 最近修改时间

			String[] rets = ret.split("<<::>>");
			logger.info("追加保单文件到影像平台返回信息:" + ret);
			// 成功 返回成功信息success
			// 失败 返回失败信息+异常代码,例如: FAIL<<::>>733
			if (rets.length > 2) {// 失败
				upImageSysReslut = false;
				String remark = "追加保单文件到影像平台出错！";
				throw new Exception(remark + ret);
			} else {
				upLoadFileVo.setAddFileState(ret);// 追加文件状态
				upImageSysReslut = true;// 上传保单文件到影像系统处理结果
			}
			if (upImageSysReslut) {// 上传保单文件到影像系统处理结果
				logger.info("当前新增/更新上传影像平台信息数据为:" + JSONObject.toJSONString(upLoadFileVo));
				UpLoadFileVO queryUpLoadFileVO = upLoadFileService.queryUploadFileByApplySeqAndImageType(upLoadFileVo);
				if (Objects.nonNull(queryUpLoadFileVO) && !StringUtil.isNullorBank(queryUpLoadFileVO.getApplySeq())) {
					upLoadFileNum = upLoadFileService.updateUpLoadFile(upLoadFileVo);
				} else {
					upLoadFileNum = upLoadFileService.insertUpLoadFile(upLoadFileVo);
				}
				logger.info("当前新增/更新上传影像平台信息数据条数为:" + upLoadFileNum);
			}
		} else {
			upImageSysReslut = false;
			String remark = "改保单文件没有找到改申请信息在影像系统的批次号！";
			throw new Exception(remark);
		}
		if (upLoadFileNum > 0) {
			result = true;
		}
		return result;
	}

	/**
	 * 
	 * @param regex
	 *            中文正则表达式
	 * @param str
	 * @return
	 */
	private boolean isMatchesCn(String str) {
		if (null == str)
			return false;
		Pattern p = Pattern.compile("[\\u4e00-\\u9fa5]");
		Matcher m = p.matcher(str);
		if (m.find()) {
			return true;
		}
		return false;
	}
}
